home *** CD-ROM | disk | FTP | other *** search
/ Champak 33 / Volume 33 - JOGO DISK .iso / Games / pin_ball_deluxe.swf / scripts / DefineSprite_421 / frame_1 / DoAction_2.as next >
Text File  |  2007-01-15  |  8KB  |  252 lines
  1. function findPossibleSegmentTarget()
  2. {
  3.    antSeg = segmentT;
  4.    _root.ballrightBumper = false;
  5.    _root.ballleftBumper = false;
  6.    _root.ballrightTargetBlock = false;
  7.    _root.ballleftTargetBlock = false;
  8.    _root.ballrightFlipper = false;
  9.    _root.ballleftFlipper = false;
  10.    _root.ballrightRamp2 = false;
  11.    _root.ballleftRamp2 = false;
  12.    _root.ballrightRamp1 = false;
  13.    _root.ballleftRamp1 = false;
  14.    tempSegments = new Array();
  15.    if(_root.ballrightBumper != true && _root.ballrightTargetBlock != true && _root.ballleftTargetBlock != true && _root.ballrightFlipper != true && _root.ballleftFlipper != true && _root.ballrightRamp2 != true && _root.ballleftRamp2 != true && _root.ballrightRamp1 != true && _root.ballleftRamp1 != true)
  16.    {
  17.       for(var _loc5_ in _root.splitSegment1)
  18.       {
  19.          if(_root.splitSegment1[_loc5_].isPossibleTarget(this))
  20.          {
  21.             tempSegments[tempSegments.length] = _root.splitSegment1[_loc5_];
  22.          }
  23.       }
  24.    }
  25.    if(this._x > _root.tbRLine._x)
  26.    {
  27.       for(_loc5_ in _root.splitSegment6)
  28.       {
  29.          if(_root.splitSegment6[_loc5_].isPossibleTarget(this))
  30.          {
  31.             tempSegments[tempSegments.length] = _root.splitSegment6[_loc5_];
  32.          }
  33.       }
  34.    }
  35.    for(_loc5_ in _root.splitSegment2)
  36.    {
  37.       if(_root.splitSegment2[_loc5_].isPossibleTarget(this))
  38.       {
  39.          tempSegments[tempSegments.length] = _root.splitSegment2[_loc5_];
  40.       }
  41.    }
  42.    if(this._y > _root.brTLine._y)
  43.    {
  44.       if(this._x > _root.brRLine2._x)
  45.       {
  46.          if(this._x < _root.brRLine1._x)
  47.          {
  48.             _root.ballrightBumper = true;
  49.             for(_loc5_ in _root.splitSegment3)
  50.             {
  51.                if(_root.splitSegment3[_loc5_].isPossibleTarget(this))
  52.                {
  53.                   tempSegments[tempSegments.length] = _root.splitSegment3[_loc5_];
  54.                }
  55.             }
  56.          }
  57.       }
  58.    }
  59.    if(this._y < _root.topBLine._y)
  60.    {
  61.       for(_loc5_ in _root.splitSegment4)
  62.       {
  63.          if(_root.splitSegment4[_loc5_].isPossibleTarget(this))
  64.          {
  65.             tempSegments[tempSegments.length] = _root.splitSegment4[_loc5_];
  66.          }
  67.       }
  68.       for(_loc5_ in _root.splitSegment5)
  69.       {
  70.          if(_root.splitSegment5[_loc5_].isPossibleTarget(this))
  71.          {
  72.             tempSegments[tempSegments.length] = _root.splitSegment5[_loc5_];
  73.          }
  74.       }
  75.    }
  76.    if(this._y > _root.ramp2T._y)
  77.    {
  78.       if(this._y < _root.ramp2B._y)
  79.       {
  80.          if(this._x > _root.ramp2L1._x)
  81.          {
  82.             if(this._x < _root.ramp2L2._x)
  83.             {
  84.                _root.ballleftRamp2 = true;
  85.                for(_loc5_ in _root.splitSegment7)
  86.                {
  87.                   if(_root.splitSegment7[_loc5_].isPossibleTarget(this))
  88.                   {
  89.                      tempSegments[tempSegments.length] = _root.splitSegment7[_loc5_];
  90.                   }
  91.                }
  92.                for(_loc5_ in _root.splitSegment11)
  93.                {
  94.                   if(_root.splitSegment11[_loc5_].isPossibleTarget(this))
  95.                   {
  96.                      tempSegments[tempSegments.length] = _root.splitSegment11[_loc5_];
  97.                   }
  98.                }
  99.                for(_loc5_ in _root.splitSegment17)
  100.                {
  101.                   if(_root.splitSegment17[_loc5_].isPossibleTarget(this))
  102.                   {
  103.                      tempSegments[tempSegments.length] = _root.splitSegment17[_loc5_];
  104.                   }
  105.                }
  106.             }
  107.          }
  108.          if(this._x > _root.ramp2R2._x)
  109.          {
  110.             if(this._x < _root.ramp2R1._x)
  111.             {
  112.                _root.ballrightRamp2 = true;
  113.                for(_loc5_ in _root.splitSegment9)
  114.                {
  115.                   if(_root.splitSegment9[_loc5_].isPossibleTarget(this))
  116.                   {
  117.                      tempSegments[tempSegments.length] = _root.splitSegment9[_loc5_];
  118.                   }
  119.                }
  120.                for(_loc5_ in _root.splitSegment12)
  121.                {
  122.                   if(_root.splitSegment12[_loc5_].isPossibleTarget(this))
  123.                   {
  124.                      tempSegments[tempSegments.length] = _root.splitSegment12[_loc5_];
  125.                   }
  126.                }
  127.             }
  128.          }
  129.       }
  130.    }
  131.    if(this._y > _root.ramp1T._y)
  132.    {
  133.       if(this._y < _root.ramp1B._y)
  134.       {
  135.          if(this._x > _root.ramp1L1._x)
  136.          {
  137.             if(this._x < _root.ramp1L2._x)
  138.             {
  139.                _root.ballleftRamp1 = true;
  140.                for(_loc5_ in _root.splitSegment8)
  141.                {
  142.                   if(_root.splitSegment8[_loc5_].isPossibleTarget(this))
  143.                   {
  144.                      tempSegments[tempSegments.length] = _root.splitSegment8[_loc5_];
  145.                   }
  146.                }
  147.             }
  148.          }
  149.          if(this._x > _root.ramp1R2._x)
  150.          {
  151.             if(this._x < _root.ramp1R1._x)
  152.             {
  153.                _root.ballrightRamp1 = true;
  154.                for(_loc5_ in _root.splitSegment10)
  155.                {
  156.                   if(_root.splitSegment10[_loc5_].isPossibleTarget(this))
  157.                   {
  158.                      tempSegments[tempSegments.length] = _root.splitSegment10[_loc5_];
  159.                   }
  160.                }
  161.             }
  162.          }
  163.       }
  164.    }
  165.    if(this._y > _root.frTLine._y)
  166.    {
  167.       if(this._y < _root.frBLine._y)
  168.       {
  169.          if(this._x > _root.frLLine1._x)
  170.          {
  171.             if(this._x < _root.frLLine2._x)
  172.             {
  173.                _root.ballleftFlipper = true;
  174.                for(_loc5_ in _root.splitSegment16)
  175.                {
  176.                   if(_root.splitSegment16[_loc5_].isPossibleTarget(this))
  177.                   {
  178.                      tempSegments[tempSegments.length] = _root.splitSegment16[_loc5_];
  179.                   }
  180.                }
  181.             }
  182.          }
  183.          if(this._x > _root.frRLine2._x)
  184.          {
  185.             if(this._x < _root.frRLine1._x)
  186.             {
  187.                _root.ballrightFlipper = true;
  188.                for(_loc5_ in _root.splitSegment15)
  189.                {
  190.                   if(_root.splitSegment15[_loc5_].isPossibleTarget(this))
  191.                   {
  192.                      tempSegments[tempSegments.length] = _root.splitSegment15[_loc5_];
  193.                   }
  194.                }
  195.             }
  196.          }
  197.       }
  198.    }
  199.    if(this._y > _root.tbTLine._y)
  200.    {
  201.       if(this._y < _root.tbBLine._y)
  202.       {
  203.          if(this._x > _root.tbRLine._x)
  204.          {
  205.             _root.ballrightTargetBlock = true;
  206.             for(_loc5_ in _root.splitSegment13)
  207.             {
  208.                if(_root.splitSegment13[_loc5_].isPossibleTarget(this))
  209.                {
  210.                   tempSegments[tempSegments.length] = _root.splitSegment13[_loc5_];
  211.                }
  212.             }
  213.          }
  214.          else if(this._x < _root.tbLLine._x)
  215.          {
  216.             _root.ballleftTargetBlock = true;
  217.             for(_loc5_ in _root.splitSegment14)
  218.             {
  219.                if(_root.splitSegment14[_loc5_].isPossibleTarget(this))
  220.                {
  221.                   tempSegments[tempSegments.length] = _root.splitSegment14[_loc5_];
  222.                }
  223.             }
  224.          }
  225.       }
  226.    }
  227.    if(tempSegments.length == 1)
  228.    {
  229.       segmentT = tempSegments[0];
  230.       return undefined;
  231.    }
  232.    segMinDistance = 100000;
  233.    var _loc4_ = -1;
  234.    for(_loc5_ in tempSegments)
  235.    {
  236.       var _loc3_ = tempSegments[_loc5_].cachedDistance;
  237.       if(_loc3_ < segMinDistance && (_loc3_ > 0 || segmentT == tempSegments[_loc5_] || tempSegments[_loc5_].isCrossed))
  238.       {
  239.          segMinDistance = _loc3_;
  240.          _loc4_ = _loc5_;
  241.       }
  242.    }
  243.    if(_loc4_ != -1)
  244.    {
  245.       segmentT = tempSegments[_loc4_];
  246.    }
  247.    else
  248.    {
  249.       segmentT = null;
  250.    }
  251. }
  252.